/************************************************************
   Copyright 2008 Abhinav Pobbati

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*************************************************************/

#pragma once
#include "Havok4Xna/Physics/Collide/HkpCollide.h"

#pragma unmanaged
#include <Physics/Collide/Agent/ContactMgr/hkpContactMgr.h>
#include <Physics/Collide/Agent/Query/hkpCdBodyPairCollector.h>
#include <Physics/Collide/Agent/Query/hkpCdPointCollector.h>
#include <Physics/Collide/Agent/hkpCollisionAgent.h>
#include <Physics/Collide/Agent/Util/LinearCast/hkpIterativeLinearCastAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/BoxBox/hkpBoxBoxAgent.h>
#include <Physics/Collide/Agent/MiscAgent/Bv/hkpBvAgent.h>
#include <Physics/Collide/Agent/CompoundAgent/BvTree/hkpBvTreeAgent.h>
#include <Physics/Collide/Agent/CompoundAgent/BvTreeStream/hkpBvTreeStreamAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/CapsuleCapsule/hkpCapsuleCapsuleAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/CapsuleTriangle/hkpCapsuleTriangleAgent.h>
#include <Physics/Collide/Agent/Collidable/hkpCdBody.h>
#include <Physics/Collide/Agent/Collidable/hkpCdPoint.h>
#include <Physics/Collide/Agent/Collidable/hkpCollidable.h>
#include <Physics/Collide/Agent/hkpCollisionAgentConfig.h>
#include <Physics/Collide/Agent/hkpCollisionInput.h>
#include <Physics/Collide/Agent/hkpCollisionQualityInfo.h>
#include <Physics/Collide/Agent/ConvexAgent/Gjk/hkpGskBaseAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/Gjk/hkpGskfAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/Gjk/hkpPredGskfAgent.h>
#include <Physics/Collide/Agent/Deprecated/ConvexList/hkpConvexListAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/Gjk/hkpGskConvexConvexAgent.h>
#include <Physics/Collide/Agent/HeightFieldAgent/hkpHeightFieldAgent.h>
#include <Physics/Collide/Agent/Query/hkpLinearCastCollisionInput.h>
#include <Physics/Collide/Agent/CompoundAgent/List/hkpListAgent.h>
#include <Physics/Collide/Agent/CompoundAgent/BvTree/hkpMoppAgent.h>
#include <Physics/Collide/Agent/CompoundAgent/BvTreeStream/hkpMoppBvTreeStreamAgent.h>
#include <Physics/Collide/Agent/MiscAgent/MultirayConvex/hkpMultiRayConvexAgent.h>
#include <Physics/Collide/Agent/Deprecated/MultiSphere/hkpMultiSphereAgent.h>
#include <Physics/Collide/Agent/Deprecated/MultiSphereTriangle/hkpMultiSphereTriangleAgent.h>
#include <Physics/Collide/Agent/Util/Null/hkpNullAgent.h>
#include <Physics/Collide/Agent/MiscAgent/Phantom/hkpPhantomAgent.h>
#include <Physics/Collide/Agent/hkpProcessCdPoint.h>
#include <Physics/Collide/Agent/hkpProcessCollisionData.h>
#include <Physics/Collide/Agent/hkpProcessCollisionInput.h>
#include <Physics/Collide/Agent/hkpProcessCollisionOutput.h>
#include <Physics/Collide/Agent/CompoundAgent/ShapeCollection/hkpShapeCollectionAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/SphereBox/hkpSphereBoxAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/SphereCapsule/hkpSphereCapsuleAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/SphereSphere/hkpSphereSphereAgent.h>
#include <Physics/Collide/Agent/ConvexAgent/SphereTriangle/hkpSphereTriangleAgent.h>
#include <Physics/Collide/Agent/Util/Symmetric/hkpSymmetricAgentLinearCast.h>
#include <Physics/Collide/Agent/MiscAgent/Transform/hkpTransformAgent.h>
#pragma managed

namespace Havok4Xna {
	namespace Physics {
		namespace Collide {
			public ref class HkpContactMgr : public INativeReference {
			public:
				enum class Type : int {
					SimpleConstraintContactMgr = hkpContactMgr::TYPE_SIMPLE_CONSTRAINT_CONTACT_MGR,
					ReportContactMgr = hkpContactMgr::TYPE_REPORT_CONTACT_MGR,
					ConvexListContactMgr = hkpContactMgr::TYPE_CONVEX_LIST_CONTACT_MGR,
					NullContactMgr = hkpContactMgr::TYPE_NULL_CONTACT_MGR,
					UserContactMgr = hkpContactMgr::TYPE_USER_CONTACT_MGR
				};

				enum class ToiAccept : int {
					Accept = hkpContactMgr::TOI_ACCEPT,
					Reject = hkpContactMgr::TOI_REJECT
				};

			internal:
				HK_CLASS_INTERNALS(HkpContactMgr, hkpContactMgr)
			};

			public ref class HkpCdBodyPairCollector : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpCdBodyPairCollector, hkpCdBodyPairCollector)
			};

			public ref class HkpCdPointCollector : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpCdPointCollector, hkpCdPointCollector)
			};

			public ref class HkpCollisionAgent : public INativeReference {
			internal:
				HK_CLASS_INTERNALS_1(HkpCollisionAgent, hkpCollisionAgent)
			};

			public ref class HkpIterativeLinearCastAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpIterativeLinearCastAgent, hkpIterativeLinearCastAgent, HkpCollisionAgent)
			};

			public ref class HkpBoxBoxAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpBoxBoxAgent, hkpBoxBoxAgent, HkpIterativeLinearCastAgent)
			};

			public ref class HkpBvAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpBvAgent, hkpBvAgent, HkpCollisionAgent)
			};

			public ref class HkpBvTreeAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpBvTreeAgent, hkpBvTreeAgent, HkpCollisionAgent)
			};

			public ref class HkpBvTreeStreamAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpBvTreeStreamAgent, hkpBvTreeStreamAgent, HkpCollisionAgent)
			};

			public ref class HkpCapsuleCapsuleAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpCapsuleCapsuleAgent, hkpCapsuleCapsuleAgent, HkpIterativeLinearCastAgent)
			};
			
			public ref class HkpCapsuleTriangleAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpCapsuleTriangleAgent, hkpCapsuleTriangleAgent, HkpIterativeLinearCastAgent)
			};

			public ref class HkpCdBody : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpCdBody, hkpCdBody)
			};

			public ref class HkpCdPoint : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpCdPoint, hkpCdPoint)
			};

			public ref class HkpCollidable : public HkpCdBody {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpCollidable, hkpCollidable, HkpCdBody)
			};

			public ref class HkpCollisionAgentConfig : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpCollisionAgentConfig, hkpCollisionAgentConfig)
			};

			public ref class HkpCollisionInput : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpCollisionInput, hkpCollisionInput)
			};

			public ref class HkpCollisionQualityInfo : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpCollisionQualityInfo, hkpCollisionQualityInfo)
			};

			public ref class HkpGskBaseAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpGskBaseAgent, hkpGskBaseAgent, HkpIterativeLinearCastAgent)
			};

			public ref class HkpGskfAgent : public HkpGskBaseAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpGskfAgent, hkpGskfAgent, HkpGskBaseAgent)
			};

			public ref class HkpPredGskfAgent : public HkpGskfAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpPredGskfAgent, hkpPredGskfAgent, HkpGskfAgent)
			};

			ATTR_DEPRECATED
			public ref class HkpConvexListAgent : public HkpPredGskfAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpConvexListAgent, hkpConvexListAgent, HkpPredGskfAgent)
			};

			public ref class HkpGskConvexConvexAgent : public HkpGskBaseAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpGskConvexConvexAgent, hkpGskConvexConvexAgent, HkpGskBaseAgent)
			};

			public ref class HkpHeightFieldAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpHeightFieldAgent, hkpHeightFieldAgent, HkpCollisionAgent)
			};

			public ref class HkpLinearCastCollisionInput : public HkpCollisionInput {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpLinearCastCollisionInput, hkpLinearCastCollisionInput, HkpCollisionInput)
			};

			public ref class HkpListAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpListAgent, hkpListAgent, HkpCollisionAgent)
			};

			public ref class HkpMoppAgent : public HkpBvTreeAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpMoppAgent, hkpMoppAgent, HkpBvTreeAgent)
			};

			public ref class HkpMoppBvTreeStreamAgent : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpMoppBvTreeStreamAgent, hkpMoppBvTreeStreamAgent)
			};

			public ref class HkpMultiRayConvexAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpMultiRayConvexAgent, hkpMultiRayConvexAgent, HkpIterativeLinearCastAgent)
			};

			ATTR_DEPRECATED
			public ref class HkpMultiSphereAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpMultiSphereAgent, hkpMultiSphereAgent, HkpCollisionAgent)
			};

			ATTR_DEPRECATED
			public ref class HkpMultiSphereTriangleAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpMultiSphereTriangleAgent, hkpMultiSphereTriangleAgent, HkpIterativeLinearCastAgent)
			};

			public ref class HkpNullAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpNullAgent, hkpNullAgent, HkpCollisionAgent)
			};

			public ref class HkpPhantomAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpPhantomAgent, hkpPhantomAgent, HkpCollisionAgent)
			};

			public ref class HkpProcessCdPoint : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpProcessCdPoint, hkpProcessCdPoint)
			};

			public ref class HkpProcessCollisionData : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpProcessCollisionData, hkpProcessCollisionData)
			};

			public ref class HkpProcessCollisionInput : public INativeReference {
			internal:
				HK_CLASS_INTERNALS(HkpProcessCollisionInput, hkpProcessCollisionInput)
			};

			public ref class HkpProcessCollisionOutput : public HkpProcessCollisionData {
			public:
				ref class PotentialInfo : public INativeReference {
				internal:
					HK_CLASS_INTERNALS(PotentialInfo, hkpProcessCollisionOutput::PotentialInfo)
				};
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpProcessCollisionOutput, hkpProcessCollisionOutput, HkpProcessCollisionData)
			};

			public ref class HkpShapeCollectionAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpShapeCollectionAgent, hkpShapeCollectionAgent, HkpCollisionAgent)
			};

			public ref class HkpSphereBoxAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpSphereBoxAgent, hkpSphereBoxAgent, HkpIterativeLinearCastAgent)
			};

			public ref class HkpSphereCapsuleAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpSphereCapsuleAgent, hkpSphereCapsuleAgent, HkpIterativeLinearCastAgent)
			};

			public ref class HkpSphereSphereAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpSphereSphereAgent, hkpSphereSphereAgent, HkpIterativeLinearCastAgent)
			};

			public ref class HkpSphereTriangleAgent : public HkpIterativeLinearCastAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpSphereTriangleAgent, hkpSphereTriangleAgent, HkpIterativeLinearCastAgent)
			};

			public ref class HkpSymmetricAgentFlipBodyCollector : public HkpCdBodyPairCollector {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpSymmetricAgentFlipBodyCollector, hkpSymmetricAgentFlipBodyCollector, HkpCdBodyPairCollector)
			};

			public ref class HkpSymmetricAgentFlipCastCollector : public HkpCdPointCollector {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpSymmetricAgentFlipCastCollector, hkpSymmetricAgentFlipCastCollector, HkpCdPointCollector)
			};

			public ref class HkpSymmetricAgentFlipCollector : public HkpCdPointCollector {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpSymmetricAgentFlipCollector, hkpSymmetricAgentFlipCollector, HkpCdPointCollector)
			};

			public ref class HkpTransformAgent : public HkpCollisionAgent {
			internal:
				HK_DERIVED_CLASS_INTERNALS(HkpTransformAgent, hkpTransformAgent, HkpCollisionAgent)
			};
		}
	}
}
